home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / quodlibet / qltk / completion.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  7KB  |  207 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. from gi.repository import Gtk
  5. from quodlibet import formats, config, print_d
  6. from quodlibet.util import copool, massagers
  7. from quodlibet.util.tags import MACHINE_TAGS
  8.  
  9. class EntryWordCompletion(Gtk.EntryCompletion):
  10.     '''Entry completion for simple words, where a word boundary is
  11.     roughly equivalent to the separators in the QL query language.
  12.  
  13.     You need to manually set a model containing the available words.'''
  14.     leftsep = [
  15.         '&(',
  16.         '|(',
  17.         ',',
  18.         ', ']
  19.     rightsep = [
  20.         ' ',
  21.         ')',
  22.         ',']
  23.     
  24.     def __init__(self):
  25.         super(EntryWordCompletion, self).__init__()
  26.         self.set_match_func(self._EntryWordCompletion__match_filter, None)
  27.         self.connect('match-selected', self._EntryWordCompletion__match_selected)
  28.  
  29.     
  30.     def __match_filter(self, completion, entrytext, iter, data):
  31.         model = completion.get_model()
  32.         entry = self.get_entry()
  33.         entrytext = entrytext.decode('utf-8')
  34.         if entry is None:
  35.             return False
  36.         cursor = None.get_position()
  37.         if cursor != len(entrytext) and not max([ entrytext[cursor:].startswith(s) for s in self.rightsep ]):
  38.             return False
  39.         (left, f) = None([ (entrytext.rfind(c, 0, cursor), c) for c in self.leftsep ])
  40.         if left < 0:
  41.             left += 1
  42.         else:
  43.             left += len(f)
  44.         if left == cursor:
  45.             return False
  46.         key = None[left:cursor]
  47.         value = model.get_value(iter, self.get_property('text-column'))
  48.         if value:
  49.             pass
  50.         return bool(value.startswith(key))
  51.  
  52.     
  53.     def __match_selected(self, completion, model, iter):
  54.         value = model.get_value(iter, self.get_property('text-column'))
  55.         entry = self.get_entry()
  56.         cursor = entry.get_position()
  57.         text = entry.get_text()
  58.         text = text.decode('utf-8')
  59.         (left, f) = max([ (text.rfind(c, 0, cursor), c) for c in self.leftsep ])
  60.         if left == -1:
  61.             left += 1
  62.         else:
  63.             left += len(f)
  64.         offset = cursor - left
  65.         entry.insert_text(value[offset:], cursor)
  66.         entry.set_position(left + len(value))
  67.         return True
  68.  
  69.  
  70.  
  71. class LibraryTagCompletion(EntryWordCompletion):
  72.     """A completion for text entries tied to a library's tag list."""
  73.     __tags = set()
  74.     
  75.     def __init__(self, library):
  76.         super(LibraryTagCompletion, self).__init__()
  77.         
  78.         try:
  79.             model = self._LibraryTagCompletion__model
  80.         except AttributeError:
  81.             model = type(self)._LibraryTagCompletion__model = Gtk.ListStore(str)
  82.             library.connect('changed', self._LibraryTagCompletion__update_song, model)
  83.             library.connect('added', self._LibraryTagCompletion__update_song, model)
  84.             library.connect('removed', self._LibraryTagCompletion__update_song, model)
  85.             copool.add(self._LibraryTagCompletion__build_model, library, model)
  86.  
  87.         self.set_model(model)
  88.         self.set_text_column(0)
  89.  
  90.     
  91.     def __update_song(klass, library, songs, model):
  92.         print_d('Updating tag model for %d songs' % len(songs))
  93.         tags = klass._LibraryTagCompletion__tags
  94.         for song in songs:
  95.             for tag in song.keys():
  96.                 if not tag.startswith('~#') and tag in MACHINE_TAGS:
  97.                     if not tag in tags:
  98.                         klass._LibraryTagCompletion__tags.add(tag)
  99.                         model.append([
  100.                             tag])
  101.                         continue
  102.                 print_d('Done updating tag model for %d songs' % len(songs))
  103.                 return None
  104.  
  105.     __update_song = classmethod(__update_song)
  106.     
  107.     def __build_model(klass, library, model):
  108.         print_d('Updating tag model for whole library')
  109.         all_tags = klass._LibraryTagCompletion__tags
  110.         model.clear()
  111.         tags = set()
  112.         songs = list(library)
  113.         for count, song in enumerate(songs):
  114.             for tag in song.keys():
  115.                 if not tag.startswith('~#'):
  116.                     if not tag in MACHINE_TAGS:
  117.                         tags.add(tag)
  118.                         continue
  119.                     if not count % 500 == 0:
  120.                         if count + 1 == len(songs):
  121.                             tags -= all_tags
  122.                             for tag in tags:
  123.                                 model.append([
  124.                                     tag])
  125.                             
  126.             all_tags.update(tags)
  127.             tags.clear()
  128.             yield True
  129.             continue
  130.         
  131.         tags.update([
  132.             '~dirname',
  133.             '~basename',
  134.             '~people',
  135.             '~format'])
  136.         for tag in [
  137.             'track',
  138.             'disc',
  139.             'playcount',
  140.             'skipcount',
  141.             'lastplayed',
  142.             'mtime',
  143.             'added',
  144.             'rating',
  145.             'length']:
  146.             tags.add('#(' + tag)
  147.         
  148.         for tag in [
  149.             'date',
  150.             'bpm']:
  151.             if tag in all_tags:
  152.                 tags.add('#(' + tag)
  153.                 continue
  154.         tags -= all_tags
  155.         for tag in tags:
  156.             model.append([
  157.                 tag])
  158.         
  159.         all_tags.update(tags)
  160.         print_d('Done updating tag model for whole library')
  161.  
  162.     __build_model = classmethod(__build_model)
  163.  
  164.  
  165. class LibraryValueCompletion(Gtk.EntryCompletion):
  166.     '''Entry completion for a library value, for a specific tag.
  167.     Will add valid values from the tag massager where available'''
  168.     
  169.     def __init__(self, tag, library):
  170.         super(LibraryValueCompletion, self).__init__()
  171.         self.set_model(Gtk.ListStore(str))
  172.         self.set_text_column(0)
  173.         self.set_tag(tag, library)
  174.  
  175.     
  176.     def set_tag(self, tag, library):
  177.         if not config.getboolean('settings', 'eager_search'):
  178.             return None
  179.         if None is None:
  180.             return None
  181.         if None in 'bpm date discnumber isrc originaldate recordingdate tracknumber title'.split() + MACHINE_TAGS:
  182.             return None
  183.         if None in formats.PEOPLE:
  184.             tag = '~people'
  185.         copool.add(self._LibraryValueCompletion__fill_tag, tag, library)
  186.  
  187.     
  188.     def __fill_tag(self, tag, library):
  189.         model = self.get_model()
  190.         model.clear()
  191.         yield True
  192.         if tag in massagers.tags:
  193.             values = massagers.tags[tag].options
  194.         else:
  195.             values = []
  196.         values = sorted(set(values + library.tag_values(tag)))
  197.         self.set_minimum_key_length(int(len(values) > 100))
  198.         yield True
  199.         for count, value in enumerate(values):
  200.             model.append(row = [
  201.                 value])
  202.             if count % 1000 == 0:
  203.                 yield True
  204.                 continue
  205.  
  206.  
  207.